home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1999 January: Mac OS SDK / Dev.CD Jan 99 SDK1.toast / Development Kits / Interfaces&Libraries / Universal / Interfaces / PInterfaces / OCEMessaging.p < prev    next >
Encoding:
Text File  |  1998-08-17  |  30.7 KB  |  1,184 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        OCEMessaging.p
  3.  
  4.      Contains:    Apple Open Collaboration Environment Messaging Interfaces.
  5.  
  6.      Version:    Technology:    AOCE Toolbox 1.02
  7.                  Release:    Universal Interfaces 3.2
  8.  
  9.      Copyright:    © 1994-1998 by Apple Computer, Inc., all rights reserved.
  10.  
  11.      Bugs?:        For bug reports, consult the following page on
  12.                  the World Wide Web:
  13.  
  14.                      http://developer.apple.com/bugreporter/
  15.  
  16. }
  17. {$IFC UNDEFINED UsingIncludes}
  18. {$SETC UsingIncludes := 0}
  19. {$ENDC}
  20.  
  21. {$IFC NOT UsingIncludes}
  22.  UNIT OCEMessaging;
  23.  INTERFACE
  24. {$ENDC}
  25.  
  26. {$IFC UNDEFINED __OCEMESSAGING__}
  27. {$SETC __OCEMESSAGING__ := 1}
  28.  
  29. {$I+}
  30. {$SETC OCEMessagingIncludes := UsingIncludes}
  31. {$SETC UsingIncludes := 1}
  32.  
  33. {$IFC UNDEFINED __FILES__}
  34. {$I Files.p}
  35. {$ENDC}
  36. {$IFC UNDEFINED __MACTYPES__}
  37. {$I MacTypes.p}
  38. {$ENDC}
  39.  
  40. {$IFC UNDEFINED __DIGITALSIGNATURE__}
  41. {$I DigitalSignature.p}
  42. {$ENDC}
  43. {$IFC UNDEFINED __OCE__}
  44. {$I OCE.p}
  45. {$ENDC}
  46. {$IFC UNDEFINED __OCEAUTHDIR__}
  47. {$I OCEAuthDir.p}
  48. {$ENDC}
  49.  
  50.  
  51. {$PUSH}
  52. {$ALIGN MAC68K}
  53. {$LibExport+}
  54.  
  55. {****************************************************************************}
  56. { Definitions common to OCEMessaging and to OCEMail. These relate to addressing,
  57. message ids and priorities, etc. }
  58.  
  59. { Values of IPMPriority }
  60.  
  61. CONST
  62.     kIPMAnyPriority                = 0;                            {  FOR FILTER ONLY  }
  63.     kIPMNormalPriority            = 1;
  64.     kIPMLowPriority                = 2;
  65.     kIPMHighPriority            = 3;
  66.  
  67.  
  68. TYPE
  69.     IPMPriority                            = Byte;
  70. { Values of IPMAccessMode }
  71.  
  72. CONST
  73.     kIPMAtMark                    = 0;
  74.     kIPMFromStart                = 1;
  75.     kIPMFromLEOM                = 2;
  76.     kIPMFromMark                = 3;
  77.  
  78.  
  79. TYPE
  80.     IPMAccessMode                        = UInt16;
  81.  
  82. CONST
  83.     kIPMUpdateMsgBit            = 4;
  84.     kIPMNewMsgBit                = 5;
  85.     kIPMDeleteMsgBit            = 6;
  86.  
  87. { Values of IPMNotificationType }
  88.     kIPMUpdateMsgMask            = $10;
  89.     kIPMNewMsgMask                = $20;
  90.     kIPMDeleteMsgMask            = $40;
  91.  
  92.  
  93. TYPE
  94.     IPMNotificationType                    = Byte;
  95. { Values of IPMSenderTag }
  96.  
  97. CONST
  98.     kIPMSenderRStringTag        = 0;
  99.     kIPMSenderRecordIDTag        = 1;
  100.  
  101.  
  102. TYPE
  103.     IPMSenderTag                        = UInt16;
  104.  
  105. CONST
  106.     kIPMFromDistListBit            = 0;
  107.     kIPMDummyRecBit                = 1;
  108.     kIPMFeedbackRecBit            = 2;                            {  should be redirected to feedback queue  }
  109.     kIPMReporterRecBit            = 3;                            {  should be redirected to reporter original queue  }
  110.     kIPMBCCRecBit                = 4;                            {  this recipient is blind to all recipients of message  }
  111.  
  112. { Values of OCERecipientOffsetFlags }
  113.     kIPMFromDistListMask        = $01;
  114.     kIPMDummyRecMask            = $02;
  115.     kIPMFeedbackRecMask            = $04;
  116.     kIPMReporterRecMask            = $08;
  117.     kIPMBCCRecMask                = $10;
  118.  
  119.  
  120. TYPE
  121.     OCERecipientOffsetFlags                = Byte;
  122.     OCECreatorTypePtr = ^OCECreatorType;
  123.     OCECreatorType = RECORD
  124.         msgCreator:                OSType;
  125.         msgType:                OSType;
  126.     END;
  127.  
  128.  
  129. CONST
  130.     kIPMTypeWildCard            = 'ipmw';
  131.     kIPMFamilyUnspecified        = 0;
  132.     kIPMFamilyWildCard            = $3F3F3F3F;                    {  '????' * well known signature  }
  133.     kIPMSignature                = 'ipms';                        {  base type * well known message types  }
  134.     kIPMReportNotify            = 'rptn';                        {  routing feedback * well known message block types  }
  135.     kIPMEnclosedMsgType            = 'emsg';                        {  enclosed (nested) message  }
  136.     kIPMReportInfo                = 'rpti';                        {  recipient information  }
  137.     kIPMDigitalSignature        = 'dsig';                        {  digital signature  }
  138.  
  139. { Values of IPMMsgFormat }
  140.     kIPMOSFormatType            = 1;
  141.     kIPMStringFormatType        = 2;
  142.  
  143.  
  144. TYPE
  145.     IPMMsgFormat                        = UInt16;
  146.     IPMStringMsgType                    = Str32;
  147.     TheTypePtr = ^TheType;
  148.     TheType = RECORD
  149.         CASE INTEGER OF
  150.         0: (
  151.             msgOSType:            OCECreatorType;
  152.             );
  153.         1: (
  154.             msgStrType:            IPMStringMsgType;
  155.             );
  156.     END;
  157.  
  158.     IPMMsgTypePtr = ^IPMMsgType;
  159.     IPMMsgType = RECORD
  160.         format:                    IPMMsgFormat;                            {  IPMMsgFormat }
  161.         theType:                TheType;
  162.     END;
  163.  
  164. {
  165. Following are the known extension values for IPM addresses handled by Apple.
  166. We define the definition of the entn extension below.
  167. }
  168.  
  169. CONST
  170.     kOCEalanXtn                    = 'alan';
  171.     kOCEentnXtn                    = 'entn';                        {  entn = entity name (aka DSSpec)  }
  172.     kOCEaphnXtn                    = 'aphn';
  173.  
  174. {
  175. Following are the specific definitions for the extension for the standard
  176. OCEMail 'entn' addresses.  [Note, the actual extension is formatted as in
  177. IPMEntityNameExtension.]
  178. }
  179. { entn extension forms }
  180.     kOCEAddrXtn                    = 'addr';
  181.     kOCEQnamXtn                    = 'qnam';
  182.     kOCEAttrXtn                    = 'attr';                        {  an attribute specification  }
  183.     kOCESpAtXtn                    = 'spat';                        {  specific attribute  }
  184.  
  185. {
  186. Following are the specific definitions for standard
  187. OCEMail 'aphn' extension value.  
  188.  
  189. All RStrings here are packed (e.g. truncated to length) and even padded (e.g.
  190. if length odd, then a pad byte (zero) should be introduced before the next field).
  191.  
  192. The extension value is in the packed form of the following structure:
  193.     RString        phoneNumber;
  194.     RString        modemType;
  195.     Str32        queueuName;
  196.  
  197. The body of phoneNumber compound RString is in the packed form of the following structure:
  198.     short         subType;
  199.     RString     countryCode;                // used when subType == kOCEUseHandyDial
  200.     RString        areaCode;                    // used when subType == kOCEUseHandyDial
  201.     RString        phone;                        // used when subType == kOCEUseHandyDial
  202.     RString        postFix;                    // used when subType == kOCEUseHandyDial
  203.     RString        nonHandyDialString;            // used when subType == kOCEDontUseHandyDial
  204. }
  205. { phoneNumber sub type constants }
  206.     kOCEUseHandyDial            = 1;
  207.     kOCEDontUseHandyDial        = 2;
  208.  
  209. { FORMAT OF A PACKED FORM RECIPIENT }
  210.  
  211. TYPE
  212.     ProtoOCEPackedRecipientPtr = ^ProtoOCEPackedRecipient;
  213.     ProtoOCEPackedRecipient = RECORD
  214.         dataLength:                UInt16;
  215.     END;
  216.  
  217.  
  218. CONST
  219.     kOCEPackedRecipientMaxBytes    = 4094;
  220.  
  221.  
  222. TYPE
  223.     OCEPackedRecipientPtr = ^OCEPackedRecipient;
  224.     OCEPackedRecipient = RECORD
  225.         dataLength:                UInt16;
  226.         data:                    PACKED ARRAY [0..4093] OF Byte;
  227.     END;
  228.  
  229.     IPMEntnQueueExtensionPtr = ^IPMEntnQueueExtension;
  230.     IPMEntnQueueExtension = RECORD
  231.         queueName:                Str32;
  232.     END;
  233.  
  234. { kOCEAttrXtn }
  235.     IPMEntnAttributeExtensionPtr = ^IPMEntnAttributeExtension;
  236.     IPMEntnAttributeExtension = RECORD
  237.         attributeName:            AttributeType;
  238.     END;
  239.  
  240. { kOCESpAtXtn }
  241.     IPMEntnSpecificAttributeExtensionPtr = ^IPMEntnSpecificAttributeExtension;
  242.     IPMEntnSpecificAttributeExtension = RECORD
  243.         attributeCreationID:    AttributeCreationID;
  244.         attributeName:            AttributeType;
  245.     END;
  246.  
  247. { All IPM entn extensions fit within the following }
  248.     IPMEntityNameExtensionPtr = ^IPMEntityNameExtension;
  249.     IPMEntityNameExtension = RECORD
  250.         subExtensionType:        OSType;
  251.         CASE INTEGER OF
  252.         0: (
  253.             specificAttribute:    IPMEntnSpecificAttributeExtension;
  254.             );
  255.         1: (
  256.             attribute:            IPMEntnAttributeExtension;
  257.             );
  258.         2: (
  259.             queue:                IPMEntnQueueExtension;
  260.             );
  261.     END;
  262.  
  263. { addresses with kIPMNBPXtn should specify this nbp type }
  264.     IPMMsgIDPtr = ^IPMMsgID;
  265.     IPMMsgID = RECORD
  266.         id:                        ARRAY [0..3] OF UInt32;
  267.     END;
  268.  
  269.  
  270. { Values of IPMHeaderSelector }
  271.  
  272. CONST
  273.     kIPMTOC                        = 0;
  274.     kIPMSender                    = 1;
  275.     kIPMProcessHint                = 2;
  276.     kIPMMessageTitle            = 3;
  277.     kIPMMessageType                = 4;
  278.     kIPMFixedInfo                = 7;
  279.  
  280.  
  281. TYPE
  282.     IPMHeaderSelector                    = Byte;
  283.     TheSenderPtr = ^TheSender;
  284.     TheSender = RECORD
  285.         CASE INTEGER OF
  286.         0: (
  287.             rString:            RString;
  288.             );
  289.         1: (
  290.             rid:                PackedRecordID;
  291.             );
  292.     END;
  293.  
  294.     IPMSenderPtr = ^IPMSender;
  295.     IPMSender = RECORD
  296.         sendTag:                IPMSenderTag;
  297.         theSender:                TheSender;
  298.     END;
  299.  
  300. {****************************************************************************}
  301. { Definitions specific to OCEMessaging }
  302.     IPMContextRef                        = UInt32;
  303.     IPMQueueRef                            = UInt32;
  304.     IPMMsgRef                            = UInt32;
  305.     IPMSeqNum                            = UInt32;
  306.     IPMProcHint                            = Str32;
  307.     IPMQueueName                        = Str32;
  308. {$IFC TYPED_FUNCTION_POINTERS}
  309.     IPMNoteProcPtr = PROCEDURE(queue: IPMQueueRef; seqNum: IPMSeqNum; notificationType: ByteParameter; userData: UInt32);
  310. {$ELSEC}
  311.     IPMNoteProcPtr = ProcPtr;
  312. {$ENDC}
  313.  
  314.     IPMNoteUPP = UniversalProcPtr;
  315.  
  316. CONST
  317.     uppIPMNoteProcInfo = $000037C0;
  318.  
  319. FUNCTION NewIPMNoteProc(userRoutine: IPMNoteProcPtr): IPMNoteUPP;
  320.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  321.     INLINE $2E9F;
  322.     {$ENDC}
  323.  
  324. PROCEDURE CallIPMNoteProc(queue: IPMQueueRef; seqNum: IPMSeqNum; notificationType: ByteParameter; userData: UInt32; userRoutine: IPMNoteUPP);
  325.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  326.     INLINE $205F, $4E90;
  327.     {$ENDC}
  328.  
  329. TYPE
  330.     IPMFixedHdrInfoPtr = ^IPMFixedHdrInfo;
  331.     IPMFixedHdrInfo = RECORD
  332.         version:                UInt16;
  333.         authenticated:            BOOLEAN;
  334.         signatureEnclosed:        BOOLEAN;                                {   digital signature enclosed  }
  335.         msgSize:                UInt32;
  336.         notification:            SInt8;
  337.         priority:                SInt8;
  338.         blockCount:                UInt16;
  339.         originalRcptCount:        UInt16;                                    {         original number of recipients  }
  340.         refCon:                    UInt32;                                    {         Client defined data  }
  341.         reserved:                UInt16;
  342.         creationTime:            UTCTime;                                {         Time when it was created  }
  343.         msgID:                    IPMMsgID;
  344.         family:                    OSType;                                    {  family this msg belongs (e.g. mail)  }
  345.     END;
  346.  
  347.  
  348. CONST
  349.     kIPMDeliveryNotificationBit    = 0;
  350.     kIPMNonDeliveryNotificationBit = 1;
  351.     kIPMEncloseOriginalBit        = 2;
  352.     kIPMSummaryReportBit        = 3;                            {  modify enclose original to only on error  }
  353.     kIPMOriginalOnlyOnErrorBit    = 4;
  354.  
  355.     kIPMNoNotificationMask        = $00;
  356.     kIPMDeliveryNotificationMask = $01;
  357.     kIPMNonDeliveryNotificationMask = $02;
  358.     kIPMDontEncloseOriginalMask    = $00;
  359.     kIPMEncloseOriginalMask        = $04;
  360.     kIPMImmediateReportMask        = $00;
  361.     kIPMSummaryReportMask        = $08;
  362.     kIPMOriginalOnlyOnErrorMask    = $10;
  363.     kIPMEncloseOriginalOnErrorMask = $14;
  364.  
  365. { standard Non delivery codes }
  366.     kIPMNoSuchRecipient            = $0001;
  367.     kIPMRecipientMalformed        = $0002;
  368.     kIPMRecipientAmbiguous        = $0003;
  369.     kIPMRecipientAccessDenied    = $0004;
  370.     kIPMGroupExpansionProblem    = $0005;
  371.     kIPMMsgUnreadable            = $0006;
  372.     kIPMMsgExpired                = $0007;
  373.     kIPMMsgNoTranslatableContent = $0008;
  374.     kIPMRecipientReqStdCont        = $0009;
  375.     kIPMRecipientReqSnapShot    = $000A;
  376.     kIPMNoTransferDiskFull        = $000B;
  377.     kIPMNoTransferMsgRejectedbyDest = $000C;
  378.     kIPMNoTransferMsgTooLarge    = $000D;
  379.  
  380. {***********************************************************************}
  381. {
  382. This is the structure that will be returned by enumerate and getmsginfo
  383. This definition is just to give you a template, the position of msgType
  384. is variable since this is a packed structure.  procHint and msgType are
  385. packed and even length padded.
  386.  
  387. * master message info }
  388.  
  389. TYPE
  390.     IPMMsgInfoPtr = ^IPMMsgInfo;
  391.     IPMMsgInfo = RECORD
  392.         sequenceNum:            IPMSeqNum;
  393.         userData:                UInt32;
  394.         respIndex:                UInt16;
  395.         padByte:                SInt8;
  396.         priority:                SInt8;
  397.         msgSize:                UInt32;
  398.         originalRcptCount:        UInt16;
  399.         reserved:                UInt16;
  400.         creationTime:            UTCTime;
  401.         msgID:                    IPMMsgID;
  402.         family:                    OSType;                                    {  family this msg belongs (e.g. mail)  }
  403.         procHint:                IPMProcHint;
  404.         filler2:                SInt8;
  405.         msgType:                IPMMsgType;
  406.     END;
  407.  
  408.     IPMBlockType                        = OCECreatorType;
  409.     IPMBlockTypePtr                     = ^IPMBlockType;
  410.     IPMTOCPtr = ^IPMTOC;
  411.     IPMTOC = RECORD
  412.         blockType:                IPMBlockType;
  413.         blockOffset:            LONGINT;
  414.         blockSize:                UInt32;
  415.         blockRefCon:            UInt32;
  416.     END;
  417.  
  418. {
  419. The following structure is just to describe the layout of the SingleFilter.
  420. Each field should be packed and word aligned when passed to the IPM ToolBox.
  421. }
  422.     IPMSingleFilterPtr = ^IPMSingleFilter;
  423.     IPMSingleFilter = RECORD
  424.         priority:                SInt8;
  425.         padByte:                SInt8;
  426.         family:                    OSType;                                    {  family this msg belongs (e.g. mail), '????' for all  }
  427.         script:                    ScriptCode;                                {  Language Identifier  }
  428.         hint:                    IPMProcHint;
  429.         filler2:                SInt8;
  430.         msgType:                IPMMsgType;
  431.     END;
  432.  
  433.     IPMFilterPtr = ^IPMFilter;
  434.     IPMFilter = RECORD
  435.         count:                    UInt16;
  436.         sFilters:                ARRAY [0..0] OF IPMSingleFilter;
  437.     END;
  438.  
  439. {************************************************************************
  440. Following structures define the “start” of a recipient report block and the
  441. elements of the array respectively.
  442. }
  443.     IPMReportBlockHeaderPtr = ^IPMReportBlockHeader;
  444.     IPMReportBlockHeader = RECORD
  445.         msgID:                    IPMMsgID;                                {  message id of the original  }
  446.         creationTime:            UTCTime;                                {  creation time of the report  }
  447.     END;
  448.  
  449.     OCERecipientReportPtr = ^OCERecipientReport;
  450.     OCERecipientReport = RECORD
  451.         rcptIndex:                UInt16;                                    {  index of recipient in original message  }
  452.         result:                    OSErr;                                    {  result of sending letter to this recipient }
  453.     END;
  454.  
  455. {***********************************************************************}
  456.     IPMParamBlockPtr = ^IPMParamBlock;
  457. {$IFC TYPED_FUNCTION_POINTERS}
  458.     IPMIOCompletionProcPtr = PROCEDURE(paramBlock: IPMParamBlockPtr);
  459. {$ELSEC}
  460.     IPMIOCompletionProcPtr = Register68kProcPtr;
  461. {$ENDC}
  462.  
  463.     IPMIOCompletionUPP = UniversalProcPtr;
  464.     IPMOpenContextPBPtr = ^IPMOpenContextPB;
  465.     IPMOpenContextPB = RECORD
  466.         qLink:                    Ptr;
  467.         reservedH1:                LONGINT;
  468.         reservedH2:                LONGINT;
  469.         ioCompletion:            IPMIOCompletionUPP;
  470.         ioResult:                OSErr;
  471.         saveA5:                    LONGINT;
  472.         reqCode:                INTEGER;
  473.         contextRef:                IPMContextRef;                            {  <--  Context reference to be used in further calls }
  474.     END;
  475.  
  476.     IPMCloseContextPB                    = IPMOpenContextPB;
  477.     IPMCloseContextPBPtr                 = ^IPMCloseContextPB;
  478.     IPMCreateQueuePBPtr = ^IPMCreateQueuePB;
  479.     IPMCreateQueuePB = RECORD
  480.         qLink:                    Ptr;
  481.         reservedH1:                LONGINT;
  482.         reservedH2:                LONGINT;
  483.         ioCompletion:            IPMIOCompletionUPP;
  484.         ioResult:                OSErr;
  485.         saveA5:                    LONGINT;
  486.         reqCode:                INTEGER;
  487.         filler1:                LONGINT;
  488.         queue:                    OCERecipientPtr;
  489.         identity:                AuthIdentity;                            {  used only if queue is remote  }
  490.         owner:                    PackedRecordIDPtr;                        {  used only if queue is remote  }
  491.     END;
  492.  
  493. { For createqueue and deletequeue only queue and identity are used }
  494.     IPMDeleteQueuePB                    = IPMCreateQueuePB;
  495.     IPMDeleteQueuePBPtr                 = ^IPMDeleteQueuePB;
  496.     IPMOpenQueuePBPtr = ^IPMOpenQueuePB;
  497.     IPMOpenQueuePB = RECORD
  498.         qLink:                    Ptr;
  499.         reservedH1:                LONGINT;
  500.         reservedH2:                LONGINT;
  501.         ioCompletion:            IPMIOCompletionUPP;
  502.         ioResult:                OSErr;
  503.         saveA5:                    LONGINT;
  504.         reqCode:                INTEGER;
  505.         contextRef:                IPMContextRef;
  506.         queue:                    OCERecipientPtr;
  507.         identity:                AuthIdentity;
  508.         filter:                    IPMFilterPtr;
  509.         newQueueRef:            IPMQueueRef;
  510.         notificationProc:        IPMNoteUPP;
  511.         userData:                UInt32;
  512.         noteType:                SInt8;
  513.         padByte:                SInt8;
  514.         reserved:                LONGINT;
  515.         reserved2:                LONGINT;
  516.     END;
  517.  
  518.     IPMCloseQueuePBPtr = ^IPMCloseQueuePB;
  519.     IPMCloseQueuePB = RECORD
  520.         qLink:                    Ptr;
  521.         reservedH1:                LONGINT;
  522.         reservedH2:                LONGINT;
  523.         ioCompletion:            IPMIOCompletionUPP;
  524.         ioResult:                OSErr;
  525.         saveA5:                    LONGINT;
  526.         reqCode:                INTEGER;
  527.         queueRef:                IPMQueueRef;
  528.     END;
  529.  
  530.     IPMEnumerateQueuePBPtr = ^IPMEnumerateQueuePB;
  531.     IPMEnumerateQueuePB = RECORD
  532.         qLink:                    Ptr;
  533.         reservedH1:                LONGINT;
  534.         reservedH2:                LONGINT;
  535.         ioCompletion:            IPMIOCompletionUPP;
  536.         ioResult:                OSErr;
  537.         saveA5:                    LONGINT;
  538.         reqCode:                INTEGER;
  539.         queueRef:                IPMQueueRef;
  540.         startSeqNum:            IPMSeqNum;
  541.         getProcHint:            BOOLEAN;
  542.         getMsgType:                BOOLEAN;
  543.         filler:                    INTEGER;
  544.         filter:                    IPMFilterPtr;
  545.         numToGet:                UInt16;
  546.         numGotten:                UInt16;
  547.         enumCount:                UInt32;
  548.         enumBuffer:                Ptr;                                    {  will be packed array of IPMMsgInfo  }
  549.         actEnumCount:            UInt32;
  550.     END;
  551.  
  552.     IPMChangeQueueFilterPB                = IPMEnumerateQueuePB;
  553.     IPMChangeQueueFilterPBPtr             = ^IPMChangeQueueFilterPB;
  554.     IPMDeleteMsgRangePBPtr = ^IPMDeleteMsgRangePB;
  555.     IPMDeleteMsgRangePB = RECORD
  556.         qLink:                    Ptr;
  557.         reservedH1:                LONGINT;
  558.         reservedH2:                LONGINT;
  559.         ioCompletion:            IPMIOCompletionUPP;
  560.         ioResult:                OSErr;
  561.         saveA5:                    LONGINT;
  562.         reqCode:                INTEGER;
  563.         queueRef:                IPMQueueRef;
  564.         startSeqNum:            IPMSeqNum;
  565.         endSeqNum:                IPMSeqNum;
  566.         lastSeqNum:                IPMSeqNum;
  567.     END;
  568.  
  569.  
  570.     IPMOpenMsgPBPtr = ^IPMOpenMsgPB;
  571.     IPMOpenMsgPB = RECORD
  572.         qLink:                    Ptr;
  573.         reservedH1:                LONGINT;
  574.         reservedH2:                LONGINT;
  575.         ioCompletion:            IPMIOCompletionUPP;
  576.         ioResult:                OSErr;
  577.         saveA5:                    LONGINT;
  578.         reqCode:                INTEGER;
  579.         queueRef:                IPMQueueRef;
  580.         sequenceNum:            IPMSeqNum;
  581.         newMsgRef:                IPMMsgRef;
  582.         actualSeqNum:            IPMSeqNum;
  583.         exactMatch:                BOOLEAN;
  584.         padByte:                SInt8;
  585.         reserved:                LONGINT;
  586.     END;
  587.  
  588.  
  589.     IPMOpenHFSMsgPBPtr = ^IPMOpenHFSMsgPB;
  590.     IPMOpenHFSMsgPB = RECORD
  591.         qLink:                    Ptr;
  592.         reservedH1:                LONGINT;
  593.         reservedH2:                LONGINT;
  594.         ioCompletion:            IPMIOCompletionUPP;
  595.         ioResult:                OSErr;
  596.         saveA5:                    LONGINT;
  597.         reqCode:                INTEGER;
  598.         hfsPath:                FSSpecPtr;
  599.         filler:                    LONGINT;
  600.         newMsgRef:                IPMMsgRef;
  601.         filler2:                LONGINT;
  602.         filler3:                SInt8;
  603.         filler4:                BOOLEAN;
  604.         reserved:                LONGINT;
  605.     END;
  606.  
  607.  
  608.     IPMOpenBlockAsMsgPBPtr = ^IPMOpenBlockAsMsgPB;
  609.     IPMOpenBlockAsMsgPB = RECORD
  610.         qLink:                    Ptr;
  611.         reservedH1:                LONGINT;
  612.         reservedH2:                LONGINT;
  613.         ioCompletion:            IPMIOCompletionUPP;
  614.         ioResult:                OSErr;
  615.         saveA5:                    LONGINT;
  616.         reqCode:                INTEGER;
  617.         msgRef:                    IPMMsgRef;
  618.         filler:                    UInt32;
  619.         newMsgRef:                IPMMsgRef;
  620.         filler2:                ARRAY [0..6] OF UInt16;
  621.         blockIndex:                UInt16;
  622.     END;
  623.  
  624.  
  625.     IPMCloseMsgPBPtr = ^IPMCloseMsgPB;
  626.     IPMCloseMsgPB = RECORD
  627.         qLink:                    Ptr;
  628.         reservedH1:                LONGINT;
  629.         reservedH2:                LONGINT;
  630.         ioCompletion:            IPMIOCompletionUPP;
  631.         ioResult:                OSErr;
  632.         saveA5:                    LONGINT;
  633.         reqCode:                INTEGER;
  634.         msgRef:                    IPMMsgRef;
  635.         deleteMsg:                BOOLEAN;
  636.         filler1:                BOOLEAN;
  637.     END;
  638.  
  639.  
  640.     IPMGetMsgInfoPBPtr = ^IPMGetMsgInfoPB;
  641.     IPMGetMsgInfoPB = RECORD
  642.         qLink:                    Ptr;
  643.         reservedH1:                LONGINT;
  644.         reservedH2:                LONGINT;
  645.         ioCompletion:            IPMIOCompletionUPP;
  646.         ioResult:                OSErr;
  647.         saveA5:                    LONGINT;
  648.         reqCode:                INTEGER;
  649.         msgRef:                    IPMMsgRef;
  650.         info:                    IPMMsgInfoPtr;
  651.     END;
  652.  
  653.  
  654.     IPMReadHeaderPBPtr = ^IPMReadHeaderPB;
  655.     IPMReadHeaderPB = RECORD
  656.         qLink:                    Ptr;
  657.         reservedH1:                LONGINT;
  658.         reservedH2:                LONGINT;
  659.         ioCompletion:            IPMIOCompletionUPP;
  660.         ioResult:                OSErr;
  661.         saveA5:                    LONGINT;
  662.         reqCode:                INTEGER;
  663.         msgRef:                    IPMMsgRef;
  664.         fieldSelector:            UInt16;
  665.         offset:                    LONGINT;
  666.         count:                    UInt32;
  667.         buffer:                    Ptr;
  668.         actualCount:            UInt32;
  669.         filler:                    UInt16;
  670.         remaining:                UInt32;
  671.     END;
  672.  
  673.  
  674.     IPMReadRecipientPBPtr = ^IPMReadRecipientPB;
  675.     IPMReadRecipientPB = RECORD
  676.         qLink:                    Ptr;
  677.         reservedH1:                LONGINT;
  678.         reservedH2:                LONGINT;
  679.         ioCompletion:            IPMIOCompletionUPP;
  680.         ioResult:                OSErr;
  681.         saveA5:                    LONGINT;
  682.         reqCode:                INTEGER;
  683.         msgRef:                    IPMMsgRef;
  684.         rcptIndex:                UInt16;
  685.         offset:                    LONGINT;
  686.         count:                    UInt32;
  687.         buffer:                    Ptr;
  688.         actualCount:            UInt32;
  689.         reserved:                INTEGER;                                {  must be zero  }
  690.         remaining:                UInt32;
  691.         originalIndex:            UInt16;
  692.         recipientOffsetFlags:    SInt8;
  693.         filler1:                BOOLEAN;
  694.     END;
  695.  
  696.  
  697. {
  698. replyQueue works like recipient. [can no longer read it via ReadHeader]
  699. OriginalIndex is meaningless, rcptFlags are used seperately and there are
  700. currently none defined.
  701. }
  702.     IPMReadReplyQueuePB                    = IPMReadRecipientPB;
  703.     IPMReadReplyQueuePBPtr                 = ^IPMReadReplyQueuePB;
  704.     IPMGetBlkIndexPBPtr = ^IPMGetBlkIndexPB;
  705.     IPMGetBlkIndexPB = RECORD
  706.         qLink:                    Ptr;
  707.         reservedH1:                LONGINT;
  708.         reservedH2:                LONGINT;
  709.         ioCompletion:            IPMIOCompletionUPP;
  710.         ioResult:                OSErr;
  711.         saveA5:                    LONGINT;
  712.         reqCode:                INTEGER;
  713.         msgRef:                    IPMMsgRef;
  714.         blockType:                IPMBlockType;
  715.         index:                    UInt16;
  716.         startingFrom:            UInt16;
  717.         actualBlockType:        IPMBlockType;
  718.         actualBlockIndex:        UInt16;
  719.     END;
  720.  
  721.  
  722.     IPMReadMsgPBPtr = ^IPMReadMsgPB;
  723.     IPMReadMsgPB = RECORD
  724.         qLink:                    Ptr;
  725.         reservedH1:                LONGINT;
  726.         reservedH2:                LONGINT;
  727.         ioCompletion:            IPMIOCompletionUPP;
  728.         ioResult:                OSErr;
  729.         saveA5:                    LONGINT;
  730.         reqCode:                INTEGER;
  731.         msgRef:                    IPMMsgRef;
  732.         mode:                    IPMAccessMode;
  733.         offset:                    LONGINT;
  734.         count:                    UInt32;
  735.         buffer:                    Ptr;
  736.         actualCount:            UInt32;
  737.         blockIndex:                UInt16;
  738.         remaining:                UInt32;
  739.     END;
  740.  
  741.     IPMVerifySignaturePBPtr = ^IPMVerifySignaturePB;
  742.     IPMVerifySignaturePB = RECORD
  743.         qLink:                    Ptr;
  744.         reservedH1:                LONGINT;
  745.         reservedH2:                LONGINT;
  746.         ioCompletion:            IPMIOCompletionUPP;
  747.         ioResult:                OSErr;
  748.         saveA5:                    LONGINT;
  749.         reqCode:                INTEGER;
  750.         msgRef:                    IPMMsgRef;
  751.         signatureContext:        SIGContextPtr;
  752.     END;
  753.  
  754.     IPMNewMsgPBPtr = ^IPMNewMsgPB;
  755.     IPMNewMsgPB = RECORD
  756.         qLink:                    Ptr;
  757.         reservedH1:                LONGINT;
  758.         reservedH2:                LONGINT;
  759.         ioCompletion:            IPMIOCompletionUPP;
  760.         ioResult:                OSErr;
  761.         saveA5:                    LONGINT;
  762.         reqCode:                INTEGER;
  763.         filler:                    UInt32;
  764.         recipient:                OCERecipientPtr;
  765.         replyQueue:                OCERecipientPtr;
  766.         procHint:                StringPtr;
  767.         filler2:                UInt16;
  768.         msgType:                IPMMsgTypePtr;
  769.         refCon:                    UInt32;
  770.         newMsgRef:                IPMMsgRef;
  771.         filler3:                UInt16;
  772.         filler4:                LONGINT;
  773.         identity:                AuthIdentity;
  774.         sender:                    IPMSenderPtr;
  775.         internalUse:            UInt32;
  776.         internalUse2:            UInt32;
  777.     END;
  778.  
  779.     IPMNewHFSMsgPBPtr = ^IPMNewHFSMsgPB;
  780.     IPMNewHFSMsgPB = RECORD
  781.         qLink:                    Ptr;
  782.         reservedH1:                LONGINT;
  783.         reservedH2:                LONGINT;
  784.         ioCompletion:            IPMIOCompletionUPP;
  785.         ioResult:                OSErr;
  786.         saveA5:                    LONGINT;
  787.         reqCode:                INTEGER;
  788.         hfsPath:                FSSpecPtr;
  789.         recipient:                OCERecipientPtr;
  790.         replyQueue:                OCERecipientPtr;
  791.         procHint:                StringPtr;
  792.         filler2:                UInt16;
  793.         msgType:                IPMMsgTypePtr;
  794.         refCon:                    UInt32;
  795.         newMsgRef:                IPMMsgRef;
  796.         filler3:                UInt16;
  797.         filler4:                LONGINT;
  798.         identity:                AuthIdentity;
  799.         sender:                    IPMSenderPtr;
  800.         internalUse:            UInt32;
  801.         internalUse2:            UInt32;
  802.     END;
  803.  
  804.     IPMNestMsgPBPtr = ^IPMNestMsgPB;
  805.     IPMNestMsgPB = RECORD
  806.         qLink:                    Ptr;
  807.         reservedH1:                LONGINT;
  808.         reservedH2:                LONGINT;
  809.         ioCompletion:            IPMIOCompletionUPP;
  810.         ioResult:                OSErr;
  811.         saveA5:                    LONGINT;
  812.         reqCode:                INTEGER;
  813.         msgRef:                    IPMMsgRef;
  814.         filler:                    ARRAY [0..8] OF UInt16;
  815.         refCon:                    UInt32;
  816.         msgToNest:                IPMMsgRef;
  817.         filler2:                UInt16;
  818.         startingOffset:            LONGINT;
  819.     END;
  820.  
  821.  
  822.     IPMNewNestedMsgBlockPBPtr = ^IPMNewNestedMsgBlockPB;
  823.     IPMNewNestedMsgBlockPB = RECORD
  824.         qLink:                    Ptr;
  825.         reservedH1:                LONGINT;
  826.         reservedH2:                LONGINT;
  827.         ioCompletion:            IPMIOCompletionUPP;
  828.         ioResult:                OSErr;
  829.         saveA5:                    LONGINT;
  830.         reqCode:                INTEGER;
  831.         msgRef:                    IPMMsgRef;
  832.         recipient:                OCERecipientPtr;
  833.         replyQueue:                OCERecipientPtr;
  834.         procHint:                StringPtr;
  835.         filler1:                UInt16;
  836.         msgType:                IPMMsgTypePtr;
  837.         refCon:                    UInt32;
  838.         newMsgRef:                IPMMsgRef;
  839.         filler2:                UInt16;
  840.         startingOffset:            LONGINT;
  841.         identity:                AuthIdentity;
  842.         sender:                    IPMSenderPtr;
  843.         internalUse:            UInt32;
  844.         internalUse2:            UInt32;
  845.     END;
  846.  
  847.  
  848.     IPMEndMsgPBPtr = ^IPMEndMsgPB;
  849.     IPMEndMsgPB = RECORD
  850.         qLink:                    Ptr;
  851.         reservedH1:                LONGINT;
  852.         reservedH2:                LONGINT;
  853.         ioCompletion:            IPMIOCompletionUPP;
  854.         ioResult:                OSErr;
  855.         saveA5:                    LONGINT;
  856.         reqCode:                INTEGER;
  857.         msgRef:                    IPMMsgRef;
  858.         msgID:                    IPMMsgID;
  859.         msgTitle:                RStringPtr;
  860.         deliveryNotification:    SInt8;
  861.         priority:                SInt8;
  862.         cancel:                    BOOLEAN;
  863.         padByte:                SInt8;
  864.         reserved:                LONGINT;
  865.         signature:                SIGSignaturePtr;
  866.         signatureSize:            Size;
  867.         signatureContext:        SIGContextPtr;
  868.                                                                         {  family this msg belongs (e.g. mail) use kIPMFamilyUnspecified by default  }
  869.         family:                    OSType;
  870.     END;
  871.  
  872.  
  873.     IPMAddRecipientPBPtr = ^IPMAddRecipientPB;
  874.     IPMAddRecipientPB = RECORD
  875.         qLink:                    Ptr;
  876.         reservedH1:                LONGINT;
  877.         reservedH2:                LONGINT;
  878.         ioCompletion:            IPMIOCompletionUPP;
  879.         ioResult:                OSErr;
  880.         saveA5:                    LONGINT;
  881.         reqCode:                INTEGER;
  882.         msgRef:                    IPMMsgRef;
  883.         recipient:                OCERecipientPtr;
  884.         reserved:                LONGINT;
  885.     END;
  886.  
  887.  
  888.     IPMAddReplyQueuePBPtr = ^IPMAddReplyQueuePB;
  889.     IPMAddReplyQueuePB = RECORD
  890.         qLink:                    Ptr;
  891.         reservedH1:                LONGINT;
  892.         reservedH2:                LONGINT;
  893.         ioCompletion:            IPMIOCompletionUPP;
  894.         ioResult:                OSErr;
  895.         saveA5:                    LONGINT;
  896.         reqCode:                INTEGER;
  897.         msgRef:                    IPMMsgRef;
  898.         filler:                    LONGINT;
  899.         replyQueue:                OCERecipientPtr;
  900.     END;
  901.  
  902.  
  903.     IPMNewBlockPBPtr = ^IPMNewBlockPB;
  904.     IPMNewBlockPB = RECORD
  905.         qLink:                    Ptr;
  906.         reservedH1:                LONGINT;
  907.         reservedH2:                LONGINT;
  908.         ioCompletion:            IPMIOCompletionUPP;
  909.         ioResult:                OSErr;
  910.         saveA5:                    LONGINT;
  911.         reqCode:                INTEGER;
  912.         msgRef:                    IPMMsgRef;
  913.         blockType:                IPMBlockType;
  914.         filler:                    ARRAY [0..4] OF UInt16;
  915.         refCon:                    UInt32;
  916.         filler2:                ARRAY [0..2] OF UInt16;
  917.         startingOffset:            LONGINT;
  918.     END;
  919.  
  920.  
  921.     IPMWriteMsgPBPtr = ^IPMWriteMsgPB;
  922.     IPMWriteMsgPB = RECORD
  923.         qLink:                    Ptr;
  924.         reservedH1:                LONGINT;
  925.         reservedH2:                LONGINT;
  926.         ioCompletion:            IPMIOCompletionUPP;
  927.         ioResult:                OSErr;
  928.         saveA5:                    LONGINT;
  929.         reqCode:                INTEGER;
  930.         msgRef:                    IPMMsgRef;
  931.         mode:                    IPMAccessMode;
  932.         offset:                    LONGINT;
  933.         count:                    UInt32;
  934.         buffer:                    Ptr;
  935.         actualCount:            UInt32;
  936.         currentBlock:            BOOLEAN;
  937.         filler1:                BOOLEAN;
  938.     END;
  939.  
  940.  
  941.  
  942.     IPMParamBlock = RECORD
  943.         CASE INTEGER OF
  944.         0: (
  945.             qLink:                Ptr;
  946.             reservedH1:            LONGINT;
  947.             reservedH2:            LONGINT;
  948.             ioCompletion:        IPMIOCompletionUPP;
  949.             ioResult:            OSErr;
  950.             saveA5:                LONGINT;
  951.             reqCode:            INTEGER;
  952.            );
  953.         1: (
  954.             openContextPB:        IPMOpenContextPB;
  955.             );
  956.         2: (
  957.             closeContextPB:        IPMCloseContextPB;
  958.             );
  959.         3: (
  960.             createQueuePB:        IPMCreateQueuePB;
  961.             );
  962.         4: (
  963.             deleteQueuePB:        IPMDeleteQueuePB;
  964.             );
  965.         5: (
  966.             openQueuePB:        IPMOpenQueuePB;
  967.             );
  968.         6: (
  969.             closeQueuePB:        IPMCloseQueuePB;
  970.             );
  971.         7: (
  972.             enumerateQueuePB:    IPMEnumerateQueuePB;
  973.             );
  974.         8: (
  975.             changeQueueFilterPB: IPMChangeQueueFilterPB;
  976.             );
  977.         9: (
  978.             deleteMsgRangePB:    IPMDeleteMsgRangePB;
  979.             );
  980.         10: (
  981.             openMsgPB:            IPMOpenMsgPB;
  982.             );
  983.         11: (
  984.             openHFSMsgPB:        IPMOpenHFSMsgPB;
  985.             );
  986.         12: (
  987.             openBlockAsMsgPB:    IPMOpenBlockAsMsgPB;
  988.             );
  989.         13: (
  990.             closeMsgPB:            IPMCloseMsgPB;
  991.             );
  992.         14: (
  993.             getMsgInfoPB:        IPMGetMsgInfoPB;
  994.             );
  995.         15: (
  996.             readHeaderPB:        IPMReadHeaderPB;
  997.             );
  998.         16: (
  999.             readRecipientPB:    IPMReadRecipientPB;
  1000.             );
  1001.         17: (
  1002.             readReplyQueuePB:    IPMReadReplyQueuePB;
  1003.             );
  1004.         18: (
  1005.             getBlkIndexPB:        IPMGetBlkIndexPB;
  1006.             );
  1007.         19: (
  1008.             readMsgPB:            IPMReadMsgPB;
  1009.             );
  1010.         20: (
  1011.             verifySignaturePB:    IPMVerifySignaturePB;
  1012.             );
  1013.         21: (
  1014.             newMsgPB:            IPMNewMsgPB;
  1015.             );
  1016.         22: (
  1017.             newHFSMsgPB:        IPMNewHFSMsgPB;
  1018.             );
  1019.         23: (
  1020.             nestMsgPB:            IPMNestMsgPB;
  1021.             );
  1022.         24: (
  1023.             newNestedMsgBlockPB: IPMNewNestedMsgBlockPB;
  1024.             );
  1025.         25: (
  1026.             endMsgPB:            IPMEndMsgPB;
  1027.             );
  1028.         26: (
  1029.             addRecipientPB:        IPMAddRecipientPB;
  1030.             );
  1031.         27: (
  1032.             addReplyQueuePB:    IPMAddReplyQueuePB;
  1033.             );
  1034.         28: (
  1035.             newBlockPB:            IPMNewBlockPB;
  1036.             );
  1037.         29: (
  1038.             writeMsgPB:            IPMWriteMsgPB;
  1039.             );
  1040.     END;
  1041.  
  1042.  
  1043. CONST
  1044.     uppIPMIOCompletionProcInfo = $00009802;
  1045.  
  1046. PROCEDURE CallIPMIOCompletionProc(paramBlock: IPMParamBlockPtr; userRoutine: IPMIOCompletionUPP);
  1047.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1048.     {To be implemented:  Glue to move parameters into registers.}
  1049.     {$ENDC}
  1050.  
  1051. FUNCTION NewIPMIOCompletionProc(userRoutine: IPMIOCompletionProcPtr): IPMIOCompletionUPP;
  1052.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1053.     INLINE $2E9F;
  1054.     {$ENDC}
  1055. FUNCTION IPMOpenContext(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1056.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1057.     INLINE $3F3C, $0400, $AA5E;
  1058.     {$ENDC}
  1059. FUNCTION IPMCloseContext(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1060.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1061.     INLINE $3F3C, $0401, $AA5E;
  1062.     {$ENDC}
  1063. FUNCTION IPMNewMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1064.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1065.     INLINE $3F3C, $0402, $AA5E;
  1066.     {$ENDC}
  1067. FUNCTION IPMNewBlock(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1068.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1069.     INLINE $3F3C, $0404, $AA5E;
  1070.     {$ENDC}
  1071. FUNCTION IPMNewNestedMsgBlock(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1072.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1073.     INLINE $3F3C, $0405, $AA5E;
  1074.     {$ENDC}
  1075. FUNCTION IPMNestMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1076.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1077.     INLINE $3F3C, $0406, $AA5E;
  1078.     {$ENDC}
  1079. FUNCTION IPMWriteMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1080.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1081.     INLINE $3F3C, $0407, $AA5E;
  1082.     {$ENDC}
  1083. FUNCTION IPMEndMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1084.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1085.     INLINE $3F3C, $0408, $AA5E;
  1086.     {$ENDC}
  1087. FUNCTION IPMOpenQueue(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1088.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1089.     INLINE $3F3C, $0409, $AA5E;
  1090.     {$ENDC}
  1091. FUNCTION IPMCloseQueue(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1092.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1093.     INLINE $3F3C, $040A, $AA5E;
  1094.     {$ENDC}
  1095. { Always synchronous }
  1096. FUNCTION IPMVerifySignature(paramBlock: IPMParamBlockPtr): OSErr;
  1097.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1098.     INLINE $7000, $1F00, $3F3C, $0422, $AA5E;
  1099.     {$ENDC}
  1100. FUNCTION IPMOpenMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1101.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1102.     INLINE $3F3C, $040B, $AA5E;
  1103.     {$ENDC}
  1104. FUNCTION IPMCloseMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1105.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1106.     INLINE $3F3C, $040C, $AA5E;
  1107.     {$ENDC}
  1108. FUNCTION IPMReadMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1109.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1110.     INLINE $3F3C, $040D, $AA5E;
  1111.     {$ENDC}
  1112. FUNCTION IPMReadHeader(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1113.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1114.     INLINE $3F3C, $040E, $AA5E;
  1115.     {$ENDC}
  1116. FUNCTION IPMOpenBlockAsMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1117.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1118.     INLINE $3F3C, $040F, $AA5E;
  1119.     {$ENDC}
  1120. FUNCTION IPMNewHFSMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1121.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1122.     INLINE $3F3C, $041E, $AA5E;
  1123.     {$ENDC}
  1124. FUNCTION IPMReadRecipient(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1125.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1126.     INLINE $3F3C, $0410, $AA5E;
  1127.     {$ENDC}
  1128. FUNCTION IPMReadReplyQueue(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1129.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1130.     INLINE $3F3C, $0421, $AA5E;
  1131.     {$ENDC}
  1132. FUNCTION IPMCreateQueue(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1133.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1134.     INLINE $3F3C, $0411, $AA5E;
  1135.     {$ENDC}
  1136. FUNCTION IPMDeleteQueue(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1137.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1138.     INLINE $3F3C, $0412, $AA5E;
  1139.     {$ENDC}
  1140. FUNCTION IPMEnumerateQueue(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1141.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1142.     INLINE $3F3C, $0413, $AA5E;
  1143.     {$ENDC}
  1144. FUNCTION IPMChangeQueueFilter(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1145.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1146.     INLINE $3F3C, $0414, $AA5E;
  1147.     {$ENDC}
  1148. FUNCTION IPMDeleteMsgRange(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1149.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1150.     INLINE $3F3C, $0415, $AA5E;
  1151.     {$ENDC}
  1152. FUNCTION IPMAddRecipient(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1153.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1154.     INLINE $3F3C, $0403, $AA5E;
  1155.     {$ENDC}
  1156. FUNCTION IPMAddReplyQueue(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1157.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1158.     INLINE $3F3C, $041D, $AA5E;
  1159.     {$ENDC}
  1160. FUNCTION IPMOpenHFSMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1161.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1162.     INLINE $3F3C, $0417, $AA5E;
  1163.     {$ENDC}
  1164. FUNCTION IPMGetBlkIndex(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1165.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1166.     INLINE $3F3C, $0418, $AA5E;
  1167.     {$ENDC}
  1168. FUNCTION IPMGetMsgInfo(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1169.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1170.     INLINE $3F3C, $0419, $AA5E;
  1171.     {$ENDC}
  1172.  
  1173.  
  1174. {$ALIGN RESET}
  1175. {$POP}
  1176.  
  1177. {$SETC UsingIncludes := OCEMessagingIncludes}
  1178.  
  1179. {$ENDC} {__OCEMESSAGING__}
  1180.  
  1181. {$IFC NOT UsingIncludes}
  1182.  END.
  1183. {$ENDC}
  1184.